import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 故我
 * Date: 2023-04-04
 * Time: 10:19
 */
public class Task {
    public static String toString(int[] array) {
        if (array == null) {
            return "null";
        }
        String tmp = "[";
        for (int i = 0; i < array.length; i++) {
            tmp += array[i];
            if (i != array.length - 1) {
                tmp += ", ";
            }
        }
        tmp += ']';

        return tmp;
    }
    public static void main(String[] args) {
        // 实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.
        int[] array1 = {1, 2, 3, 4, 5};
        String str = toString(array1);
        System.out.println(str);
    }
    public static int[] copyOf(int[] array2, int[] array1) {
        for (int i = 0; i < array1.length; i++) {
            array2[i] = array1[i];
        }

        return array2;
    }

    public static void main8(String[] args) {
        // 实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组.
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = new int[array1.length];
        copyOf(array2, array1);//dest src

        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
        System.out.println("======================");
        array2[0] = 100;
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }

    public static int binarySearch(int[] array, int key) {
        int begin = 0;
        int end = array.length - 1;
        while (begin <= end) {
            int mid = (begin + end) / 2;
            if (array[mid] > key) {
                end = mid - 1;
            } else if (array[mid] < key) {
                begin = mid + 1;
            } else {
                return mid;
            }
        }

        return -1;
    }

    public static void main7(String[] args) {
        // 给定一个有序整型数组, 实现二分查找
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int key = 7;
        int index = binarySearch(array, key);
        System.out.println(index);
    }

    public static boolean is_increase(int[] array) {
        for (int i = 1; i < array.length; i++) {
            if (array[i] < array[i - 1]) {
                return false;
            }
        }

        return true;
    }

    public static void main6(String[] args) {
        // 给定一个整型数组, 判定数组是否有序（递增）
        int[] array = {1, 2, 3, 4, 5, 6};
        boolean flag = is_increase(array);
        if (flag == false) {
            System.out.println("不是递增");
        } else {
            System.out.println("递增");
        }
    }

    public static void bubbleSort(int[] array) {
        //外层控制排序次数
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;

                    flag = true;
                }
            }

            if (flag == false) {
                break;
            }
        }
    }

    public static void main5(String[] args) {
        // 给定一个整型数组, 实现冒泡排序(升序排序)
        int[] array = {2, 3, 5, 1, 6, 8, 3, 9, 0, 3, 5, 6, 4, 10};
        long begin = System.currentTimeMillis();
        bubbleSort(array);
        long end = System.currentTimeMillis();
        System.out.println(Arrays.toString(array));
        System.out.println(begin - end);
    }

    public static int[] set(int[] array) {
        for (int i = 1; i <= array.length; i++) {
            array[i - 1] = i;
        }

        return array;
    }

    public static void main4(String[] args) {
        // 创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
        int[] array = new int[100];
        int[] array1 = set(array);
        System.out.println(Arrays.toString(array1));
    }

    public static String printArray(int[] array) {
        if (array == null) {
            return "null";
        }
        String tmp = "[";
        for (int i = 0; i < array.length; i++) {
            tmp += array[i];
            if (i != array.length - 1) {
                tmp += ", ";
            }
        }
        tmp += ']';

        return tmp;
    }

    public static void main3(String[] args) {
        // 实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.
        int[] array = new int[]{2, 3, 4, 5, 6, 7, 8, 9, 0, 1};
        String res = printArray(array);
        System.out.println(res);
    }

    public static int[] transform(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] *= 2;
        }

        return array;
    }

    public static void main2(String[] args) {
        // 实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
        int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 22};
        System.out.println(Arrays.toString(transform(array)));
    }


    public static int Sum(int[] array) {
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }

        return sum;
    }

    public static void main1(String[] args) {
        // 实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
        int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 22};
        int ret = Sum(array);
        System.out.println(ret);
    }
}
